package controller

import (
	"RocFamilySystem/internal/service"
	"RocFamilySystem/models"
	"RocFamilySystem/pkg/constant"
	"RocFamilySystem/tools/cache"
	"RocFamilySystem/tools/container"
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/go-redis/redis/v8"
	"strconv"
	"strings"
)

type SysDatabaseCacheController struct {
	BaseController
	SysDatabaseCacheService *service.SysDatabaseCacheService
}

// 初始化
func init() {
	registerContainer["SysDatabaseCacheController"] = &SysDatabaseCacheController{}
}

// SetService 设置服务
func (controller *SysDatabaseCacheController) SetService(sysSysDatabaseCacheService *service.SysDatabaseCacheService) {
	controller.SysDatabaseCacheService = sysSysDatabaseCacheService
}

// RegisterRouter 注册路由
func (controller *SysDatabaseCacheController) RegisterRouter(engine *gin.Engine) {
	prefix := "/sysDatabaseCache"
	g := engine.Group(prefix)
	prefixPermission := "permission" + strings.ReplaceAll(prefix, "/", ":")
	{
		//新增系统缓存
		g.POST("", controller.AddSysDatabaseCache)
		registerPermissionContainer("新增数据库缓存", prefixPermission+":create", prefix, "POST")
		//删除系统缓存
		g.DELETE("/:id", controller.RemoveSysDatabaseCache)
		registerPermissionContainer("删除数据库缓存", prefixPermission+":delete", prefix, "DELETE")
		g.DELETE("/batchDelete", controller.RemoveSysDatabaseCacheBatch)
		registerPermissionContainer("批量删除数据库缓存", prefixPermission+":batchDelete", prefix, "DELETE")
		//修改系统缓存
		g.PUT("", controller.ModifySysDatabaseCache)
		registerPermissionContainer("修改数据库缓存", prefixPermission+":update", prefix, "PUT")
		//获取系统缓存列表
		g.POST("/list", controller.QuerySysDatabaseCache)
		registerPermissionContainer("获取数据库缓存列表", prefixPermission+":list", prefix, "POST")
		//通过ID查询系统缓存
		g.GET("/:id", controller.QuerySysDatabaseCacheById)
		registerPermissionContainer("ID获取数据库缓存", prefixPermission+":id", prefix, "GET")
		//获取Redis中的缓存
		g.GET("", controller.GetRedisCache)
		registerPermissionContainer("获取数据库缓存", prefixPermission+"", prefix, "GET")
		//获取Redis中的缓存
		g.GET("/refresh", controller.RefreshRedisCache)
		registerPermissionContainer("刷新数据库缓存", prefixPermission+":refresh", prefix, "GET")
	}
}

// AddSysDatabaseCache 添加系统缓存
// @Summary AddSysDatabaseCache 添加系统缓存
// @Tags 系统缓存
// @Produce json
// @Param sysSysDatabaseCache body models.SysDatabaseCache true "系统缓存"
// @Success 200 {object} Result "成功"
// @Router /sysDatabaseCache [post]
func (controller *SysDatabaseCacheController) AddSysDatabaseCache(ctx *gin.Context) {
	var sysSysDatabaseCache models.SysDatabaseCache
	err := ctx.ShouldBind(&sysSysDatabaseCache)
	controller.HandleError(err, constant.PARAMS_ERROR)
	controller.SysDatabaseCacheService.AddSysDatabaseCache(&sysSysDatabaseCache)
	controller.CustomResult(ctx, 200, "添加系统缓存成功", nil)
}

// RemoveSysDatabaseCache 删除系统缓存
// @Summary RemoveSysDatabaseCache  删除系统缓存
// @Tags 系统缓存
// @Produce json
// @Param id path int true "系统缓存id"
// @Success 200 {object} Result "成功"
// @Router /sysDatabaseCache/:id [delete]
func (controller *SysDatabaseCacheController) RemoveSysDatabaseCache(ctx *gin.Context) {
	sysSysDatabaseCacheId, err := strconv.Atoi(ctx.Param("id"))
	controller.HandleError(err, constant.PARAMS_ERROR)
	controller.SysDatabaseCacheService.RemoveSysDatabaseCache(sysSysDatabaseCacheId)
	controller.CustomResult(ctx, 200, fmt.Sprintf("删除【%d】成功", sysSysDatabaseCacheId), nil)
}

// RemoveSysDatabaseCacheBatch 删除系统缓存
// @Summary RemoveSysDatabaseCache  删除系统缓存
// @Tags 系统缓存
// @Produce json
// @Param ids[] query []int true "系统缓存id"
// @Success 200 {object} Result "成功"
// @Router /sysDatabaseCache/batchDelete [delete]
func (controller *SysDatabaseCacheController) RemoveSysDatabaseCacheBatch(ctx *gin.Context) {
	ids := ctx.QueryArray("ids[]")
	if len(ids) == 0 {
		controller.HandleError(errors.New("参数缺失"), constant.PARAMS_ERROR)
	}
	controller.SysDatabaseCacheService.RemoveSysDatabaseCacheBatch(ids)
	controller.CustomResult(ctx, 200, fmt.Sprintf("删除【%v】成功", ids), nil)
}

// ModifySysDatabaseCache 修改系统缓存
// @Summary ModifySysDatabaseCache 修改系统缓存
// @Tags 系统缓存
// @Produce json
// @Param sysSysDatabaseCache body models.SysDatabaseCache true "系统缓存"
// @Success 200 {object} Result "成功"
// @Router /sysDatabaseCache [put]
func (controller *SysDatabaseCacheController) ModifySysDatabaseCache(ctx *gin.Context) {
	var sysSysDatabaseCache models.SysDatabaseCache
	err := ctx.ShouldBind(&sysSysDatabaseCache)
	controller.HandleError(err, constant.PARAMS_ERROR)
	controller.SysDatabaseCacheService.ModifySysDatabaseCache(&sysSysDatabaseCache)
	controller.CustomResult(ctx, 200, fmt.Sprintf("修改【%d】成功", *sysSysDatabaseCache.Id), nil)
}

// QuerySysDatabaseCache 查询系统缓存
// @Summary QuerySysDatabaseCache 查询系统缓存
// @Tags 系统缓存
// @Produce json
// @Param sysSysDatabaseCache body models.SysDatabaseCache true "系统缓存"
// @Success 200 {object} Result "成功"
// @Router /sysDatabaseCache/list [post]
func (controller *SysDatabaseCacheController) QuerySysDatabaseCache(ctx *gin.Context) {
	pageNum, pageSize := controller.GetPageInfo(ctx)
	var sysSysDatabaseCache models.SysDatabaseCache
	err := ctx.ShouldBind(&sysSysDatabaseCache)
	controller.HandleError(err, constant.PARAMS_ERROR)
	data := controller.SysDatabaseCacheService.QuerySysDatabaseCache(&sysSysDatabaseCache, pageNum, pageSize)
	controller.SuccessResult(ctx, data)
}

// QuerySysDatabaseCacheById 查询系统缓存通过ID
// @Summary QuerySysDatabaseCacheById  查询系统缓存通过ID
// @Tags 系统缓存
// @Produce json
// @Param id path int true "系统缓存id"
// @Success 200 {object} Result "成功"
// @Router /sysDatabaseCache/:id [get]
func (controller *SysDatabaseCacheController) QuerySysDatabaseCacheById(ctx *gin.Context) {
	sysSysDatabaseCacheId, err := strconv.Atoi(ctx.Param("id"))
	controller.HandleError(err, constant.PARAMS_ERROR)
	data := controller.SysDatabaseCacheService.QuerySysDatabaseCacheById(sysSysDatabaseCacheId)
	controller.SuccessResult(ctx, data)
}

// GetRedisCache 获取Redis中的缓存
// @Summary GetRedisCache   获取Redis中的缓存
// @Tags 系统缓存
// @Produce json
// @Success 200 {object} Result "成功"
// @Router /sysDatabaseCache [get]
func (controller *SysDatabaseCacheController) GetRedisCache(ctx *gin.Context) {
	caches := container.GetBeanFromContainer("redis.Client").(*redis.Client).HGetAll(ctx, constant.REDIS_KEY_SYS_CACHE).Val()
	controller.SuccessResult(ctx, caches)
}

// RefreshRedisCache 刷新Redis中的缓存
// @Summary RefreshRedisCache   刷新Redis中的缓存
// @Tags 系统缓存
// @Produce json
// @Success 200 {object} Result "成功"
// @Router /sysDatabaseCache/refresh [get]
func (controller *SysDatabaseCacheController) RefreshRedisCache(ctx *gin.Context) {
	cache.LoadDatabaseCache()
	controller.CustomResult(ctx, 200, "刷新系统缓存成功！", nil)
}
